home *** CD-ROM | disk | FTP | other *** search
/ Champak 140 / (Vol 140) Sep 19 2011.iso / Games / mardek_rpg.swf / scripts / DefineSprite_3269_c_GdM / frame_42 / DoAction.as
Text File  |  2011-09-19  |  53KB  |  1,100 lines

  1. function ┬º\x01\x02┬º()
  2. {
  3.    return 2816 % 511 * 5;
  4. }
  5. var ┬º\x01┬º = -313 + "\x01\x02"();
  6. loop0:
  7. while(true)
  8. {
  9.    if(eval("\x01") == 992)
  10.    {
  11.       set("\x01",eval("\x01") - 962);
  12.       ┬º┬ºpush(true);
  13.       continue;
  14.    }
  15.    if(eval("\x01") == 354)
  16.    {
  17.       set("\x01",eval("\x01") - 202);
  18.       if(function ┬º\x01\x02┬º()
  19.       {
  20.          return 2816 % 511 * 5;
  21.       })
  22.       {
  23.          set("\x01",eval("\x01") + 0);
  24.       }
  25.       continue;
  26.    }
  27.    if(eval("\x01") == 786)
  28.    {
  29.       set("\x01",eval("\x01") - 736);
  30.       ┬º┬ºpush("\x0f");
  31.       ┬º┬ºpush(1);
  32.       continue;
  33.    }
  34.    if(eval("\x01") == 52)
  35.    {
  36.       set("\x01",eval("\x01") + 734);
  37.       continue;
  38.    }
  39.    if(eval("\x01") == 50)
  40.    {
  41.       set("\x01",eval("\x01") + 471);
  42.       var ┬º┬ºpop() = function ┬º\x01\x02┬º()
  43.       {
  44.          return 2816 % 511 * 5;
  45.       };
  46.       continue;
  47.    }
  48.    if(eval("\x01") == 30)
  49.    {
  50.       set("\x01",eval("\x01") + 806);
  51.       if(function ┬º\x01\x02┬º()
  52.       {
  53.          return 2816 % 511 * 5;
  54.       })
  55.       {
  56.          set("\x01",eval("\x01") - 394);
  57.       }
  58.       continue;
  59.    }
  60.    if(eval("\x01") != 836)
  61.    {
  62.       if(eval("\x01") != 442)
  63.       {
  64.          if(eval("\x01") == 651)
  65.          {
  66.             set("\x01",eval("\x01") + 25);
  67.             ┬º┬ºpush(eval(function ┬º\x01\x02┬º()
  68.             {
  69.                return 2816 % 511 * 5;
  70.             }));
  71.             continue;
  72.          }
  73.          if(eval("\x01") != 676)
  74.          {
  75.             if(eval("\x01") != 521)
  76.             {
  77.                if(eval("\x01") == 152)
  78.                {
  79.                   set("\x01",eval("\x01") + 476);
  80.                   Say("Balthazar","blah","...");
  81.                   break;
  82.                }
  83.                if(eval("\x01") == 628)
  84.                {
  85.                   set("\x01",eval("\x01") - 628);
  86.                   break;
  87.                }
  88.             }
  89.             set("\x01",eval("\x01") + 130);
  90.             ┬º┬ºpush("\x0f");
  91.          }
  92.          set("\x01",eval("\x01") - 322);
  93.          ┬º┬ºpush(!function ┬º\x01\x02┬º()
  94.          {
  95.             return 2816 % 511 * 5;
  96.          });
  97.       }
  98.       set("\x01",eval("\x01") + 344);
  99.       continue;
  100.       continue;
  101.       continue;
  102.       break;
  103.    }
  104.    set("\x01",eval("\x01") - 394);
  105.    while(true)
  106.    {
  107.       if(┬º┬ºpop() != function ┬º\x01\x02┬º()
  108.       {
  109.          return 2816 % 511 * 5;
  110.       })
  111.       {
  112.          break loop0;
  113.       }
  114.       set("\x01",eval("\x01") + 472);
  115.       ┬º┬ºpush(true);
  116.       while(true)
  117.       {
  118.          if(eval("\x01") == 335)
  119.          {
  120.             set("\x01",eval("\x01") - 267);
  121.             ┬º┬ºpush(true);
  122.          }
  123.          else if(eval("\x01") == 629)
  124.          {
  125.             set("\x01",eval("\x01") + 202);
  126.          }
  127.          else if(eval("\x01") == 73)
  128.          {
  129.             set("\x01",eval("\x01") + 218);
  130.          }
  131.          else if(eval("\x01") == 418)
  132.          {
  133.             set("\x01",eval("\x01") + 70);
  134.             ┬º┬ºpush(eval(┬º┬ºpop()));
  135.          }
  136.          else if(eval("\x01") == 819)
  137.          {
  138.             set("\x01",eval("\x01") + 78);
  139.             if(┬º┬ºpop())
  140.             {
  141.                set("\x01",eval("\x01") + 0);
  142.             }
  143.          }
  144.          else if(eval("\x01") == 68)
  145.          {
  146.             set("\x01",eval("\x01") + 772);
  147.             if(┬º┬ºpop())
  148.             {
  149.                set("\x01",eval("\x01") - 767);
  150.             }
  151.          }
  152.          else if(eval("\x01") == 922)
  153.          {
  154.             set("\x01",eval("\x01") - 888);
  155.             var ┬º┬ºpop() = ┬º┬ºpop();
  156.          }
  157.          else
  158.          {
  159.             if(eval("\x01") == 840)
  160.             {
  161.                set("\x01",eval("\x01") - 767);
  162.                loop15:
  163.                while(true)
  164.                {
  165.                   set(┬º┬ºpop(),┬º┬ºpop());
  166.                   while(true)
  167.                   {
  168.                      if(eval("\x01") == 253)
  169.                      {
  170.                         set("\x01",eval("\x01") + 705);
  171.                         ┬º┬ºpush(true);
  172.                      }
  173.                      else if(eval("\x01") == 963)
  174.                      {
  175.                         set("\x01",eval("\x01") - 815);
  176.                         if(┬º┬ºpop())
  177.                         {
  178.                            set("\x01",eval("\x01") + 0);
  179.                         }
  180.                      }
  181.                      else
  182.                      {
  183.                         if(eval("\x01") == 148)
  184.                         {
  185.                            break loop15;
  186.                         }
  187.                         if(eval("\x01") == 641)
  188.                         {
  189.                            set("\x01",eval("\x01") + 322);
  190.                            ┬º┬ºpush(!┬º┬ºpop());
  191.                         }
  192.                         else if(eval("\x01") == 401)
  193.                         {
  194.                            set("\x01",eval("\x01") + 240);
  195.                            ┬º┬ºpush(eval(┬º┬ºpop()));
  196.                         }
  197.                         else
  198.                         {
  199.                            if(eval("\x01") == 78)
  200.                            {
  201.                               set("\x01",eval("\x01") - 78);
  202.                               break loop0;
  203.                            }
  204.                            if(eval("\x01") == 632)
  205.                            {
  206.                               set("\x01",eval("\x01") - 231);
  207.                               ┬º┬ºpush("\x0f");
  208.                            }
  209.                            else if(eval("\x01") == 508)
  210.                            {
  211.                               set("\x01",eval("\x01") - 381);
  212.                               ┬º┬ºpush("\x0f");
  213.                               ┬º┬ºpush(1);
  214.                            }
  215.                            else
  216.                            {
  217.                               if(eval("\x01") == 217)
  218.                               {
  219.                                  set("\x01",eval("\x01") + 466);
  220.                                  stop();
  221.                                  break loop0;
  222.                               }
  223.                               if(eval("\x01") == 697)
  224.                               {
  225.                                  set("\x01",eval("\x01") - 189);
  226.                               }
  227.                               else
  228.                               {
  229.                                  if(eval("\x01") == 683)
  230.                                  {
  231.                                     break;
  232.                                  }
  233.                                  if(eval("\x01") == 127)
  234.                                  {
  235.                                     set("\x01",eval("\x01") + 505);
  236.                                     var ┬º┬ºpop() = ┬º┬ºpop();
  237.                                  }
  238.                                  else
  239.                                  {
  240.                                     if(eval("\x01") != 958)
  241.                                     {
  242.                                        break loop0;
  243.                                     }
  244.                                     set("\x01",eval("\x01") - 741);
  245.                                     if(┬º┬ºpop())
  246.                                     {
  247.                                        set("\x01",eval("\x01") + 466);
  248.                                     }
  249.                                  }
  250.                               }
  251.                            }
  252.                         }
  253.                      }
  254.                   }
  255.                }
  256.                set("\x01",eval("\x01") - 70);
  257.                Say("Balthazar","blah","One of us should go to stop him. But who? Any volunteers?");
  258.                break loop0;
  259.             }
  260.             if(eval("\x01") == 34)
  261.             {
  262.                set("\x01",eval("\x01") + 384);
  263.                ┬º┬ºpush("\x0f");
  264.             }
  265.             else if(eval("\x01") == 831)
  266.             {
  267.                set("\x01",eval("\x01") + 91);
  268.                ┬º┬ºpush("\x0f");
  269.                ┬º┬ºpush(1);
  270.             }
  271.             else
  272.             {
  273.                if(eval("\x01") == 897)
  274.                {
  275.                   set("\x01",eval("\x01") - 728);
  276.                   Say("Anu","glare","When Rohoph\'s gone and dealt with, there\'ll be nothing to stop us... No... Soon, THE GALAXY WILL BE OURS!!! MWAHAHAHAHAH!!!!");
  277.                   break loop0;
  278.                }
  279.                if(eval("\x01") == 169)
  280.                {
  281.                   set("\x01",eval("\x01") - 169);
  282.                   break loop0;
  283.                }
  284.                if(eval("\x01") == 200)
  285.                {
  286.                   set("\x01",eval("\x01") + 631);
  287.                }
  288.                else if(eval("\x01") == 488)
  289.                {
  290.                   set("\x01",eval("\x01") + 331);
  291.                   ┬º┬ºpush(!┬º┬ºpop());
  292.                }
  293.                else if(eval("\x01") == 576)
  294.                {
  295.                   set("\x01",eval("\x01") - 285);
  296.                }
  297.                else
  298.                {
  299.                   if(eval("\x01") == 280)
  300.                   {
  301.                      set("\x01",eval("\x01") - 80);
  302.                      loop3:
  303.                      while(true)
  304.                      {
  305.                         set("\x01",eval("\x01") - 54);
  306.                         while(true)
  307.                         {
  308.                            if(eval("\x01") == 999)
  309.                            {
  310.                               set("\x01",eval("\x01") - 556);
  311.                               ┬º┬ºpush(true);
  312.                               continue;
  313.                            }
  314.                            if(eval("\x01") == 241)
  315.                            {
  316.                               set("\x01",eval("\x01") + 245);
  317.                               ┬º┬ºpush(!┬º┬ºpop());
  318.                               continue;
  319.                            }
  320.                            if(eval("\x01") == 283)
  321.                            {
  322.                               set("\x01",eval("\x01") - 42);
  323.                               ┬º┬ºpush(eval(┬º┬ºpop()));
  324.                               continue;
  325.                            }
  326.                            if(eval("\x01") == 962)
  327.                            {
  328.                               set("\x01",eval("\x01") + 38);
  329.                               continue;
  330.                            }
  331.                            if(eval("\x01") == 671)
  332.                            {
  333.                               break loop3;
  334.                            }
  335.                            if(eval("\x01") == 216)
  336.                            {
  337.                               set("\x01",eval("\x01") + 784);
  338.                               continue;
  339.                            }
  340.                            if(eval("\x01") == 166)
  341.                            {
  342.                               set("\x01",eval("\x01") + 319);
  343.                               continue;
  344.                            }
  345.                            if(eval("\x01") == 119)
  346.                            {
  347.                               set("\x01",eval("\x01") + 164);
  348.                               ┬º┬ºpush("\x0f");
  349.                               continue;
  350.                            }
  351.                            if(eval("\x01") == 443)
  352.                            {
  353.                               set("\x01",eval("\x01") + 318);
  354.                               if(┬º┬ºpop())
  355.                               {
  356.                                  set("\x01",eval("\x01") - 545);
  357.                               }
  358.                               continue;
  359.                            }
  360.                            if(eval("\x01") == 27)
  361.                            {
  362.                               set("\x01",eval("\x01") + 711);
  363.                               gotoAndStop("CHAPTER2");
  364.                               break loop0;
  365.                            }
  366.                            if(eval("\x01") == 750)
  367.                            {
  368.                               set("\x01",eval("\x01") - 79);
  369.                               if(┬º┬ºpop())
  370.                               {
  371.                                  set("\x01",eval("\x01") - 505);
  372.                               }
  373.                               continue;
  374.                            }
  375.                            if(eval("\x01") == 1000)
  376.                            {
  377.                               set("\x01",eval("\x01") - 250);
  378.                               ┬º┬ºpush(true);
  379.                               continue;
  380.                            }
  381.                            if(eval("\x01") == 784)
  382.                            {
  383.                               set("\x01",eval("\x01") - 665);
  384.                               var ┬º┬ºpop() = ┬º┬ºpop();
  385.                               continue;
  386.                            }
  387.                            if(eval("\x01") == 485)
  388.                            {
  389.                               set("\x01",eval("\x01") + 299);
  390.                               ┬º┬ºpush("\x0f");
  391.                               ┬º┬ºpush(1);
  392.                               continue;
  393.                            }
  394.                            if(eval("\x01") == 486)
  395.                            {
  396.                               set("\x01",eval("\x01") - 459);
  397.                               if(┬º┬ºpop())
  398.                               {
  399.                                  set("\x01",eval("\x01") + 0);
  400.                               }
  401.                               continue;
  402.                            }
  403.                            if(eval("\x01") == 761)
  404.                            {
  405.                               set("\x01",eval("\x01") - 545);
  406.                               ┬º┬ºpop() extends ┬º┬ºpop() >> (┬º┬ºpop() | ┬º┬ºpop());
  407.                               break loop0;
  408.                            }
  409.                            if(eval("\x01") != 539)
  410.                            {
  411.                               if(eval("\x01") == 738)
  412.                               {
  413.                                  set("\x01",eval("\x01") - 738);
  414.                                  break loop0;
  415.                               }
  416.                               break loop0;
  417.                            }
  418.                            continue loop3;
  419.                         }
  420.                      }
  421.                      set("\x01",eval("\x01") - 505);
  422.                      loop5:
  423.                      while(true)
  424.                      {
  425.                         set(┬º┬ºpop(),eval("\x01") - 8);
  426.                         while(true)
  427.                         {
  428.                            if(eval("\x01") != 530)
  429.                            {
  430.                               if(eval("\x01") == 995)
  431.                               {
  432.                                  set("\x01",eval("\x01") - 832);
  433.                                  loop7:
  434.                                  while(true)
  435.                                  {
  436.                                     set(┬º┬ºpop(),eval(┬º┬ºpop()) - 157);
  437.                                     while(true)
  438.                                     {
  439.                                        if(eval("\x01") == 911)
  440.                                        {
  441.                                           set("\x01",eval("\x01") - 849);
  442.                                           ┬º┬ºpush(true);
  443.                                           continue;
  444.                                        }
  445.                                        if(eval("\x01") == 572)
  446.                                        {
  447.                                           set("\x01",eval("\x01") - 367);
  448.                                           break loop0;
  449.                                        }
  450.                                        if(eval("\x01") == 48)
  451.                                        {
  452.                                           set("\x01",eval("\x01") + 297);
  453.                                           ┬º┬ºpush("\x0f");
  454.                                           ┬º┬ºpush(1);
  455.                                           continue;
  456.                                        }
  457.                                        if(eval("\x01") == 62)
  458.                                        {
  459.                                           set("\x01",eval("\x01") + 621);
  460.                                           if(┬º┬ºpop())
  461.                                           {
  462.                                              set("\x01",eval("\x01") - 562);
  463.                                           }
  464.                                           continue;
  465.                                        }
  466.                                        if(eval("\x01") == 612)
  467.                                        {
  468.                                           set("\x01",eval("\x01") - 564);
  469.                                           continue;
  470.                                        }
  471.                                        if(eval("\x01") == 416)
  472.                                        {
  473.                                           set("\x01",eval("\x01") + 156);
  474.                                           if(┬º┬ºpop())
  475.                                           {
  476.                                              set("\x01",eval("\x01") - 367);
  477.                                           }
  478.                                           continue;
  479.                                        }
  480.                                        if(eval("\x01") == 630)
  481.                                        {
  482.                                           set("\x01",eval("\x01") - 505);
  483.                                           continue;
  484.                                        }
  485.                                        if(eval("\x01") == 477)
  486.                                        {
  487.                                           set("\x01",eval("\x01") - 110);
  488.                                           Say("Miner","angr","This is stupid, what yer doing! Yer making us look for somethin\' that isn\'t \'ere! I\'m tellin\' yer, these are NONMAGIC gems! They\'re worth a pretty penny, but they ent no Magic Crystals!");
  489.                                           break loop0;
  490.                                        }
  491.                                        if(eval("\x01") == 417)
  492.                                        {
  493.                                           set("\x01",eval("\x01") - 13);
  494.                                           ┬º┬ºpush(!┬º┬ºpop());
  495.                                           continue;
  496.                                        }
  497.                                        if(eval("\x01") == 345)
  498.                                        {
  499.                                           set("\x01",eval("\x01") - 115);
  500.                                           var ┬º┬ºpop() = ┬º┬ºpop();
  501.                                           continue;
  502.                                        }
  503.                                        if(eval("\x01") == 121)
  504.                                        {
  505.                                           set("\x01",eval("\x01") + 870);
  506.                                           continue;
  507.                                        }
  508.                                        if(eval("\x01") == 125)
  509.                                        {
  510.                                           set("\x01",eval("\x01") + 291);
  511.                                           ┬º┬ºpush(true);
  512.                                           continue;
  513.                                        }
  514.                                        if(eval("\x01") == 683)
  515.                                        {
  516.                                           break loop7;
  517.                                        }
  518.                                        if(eval("\x01") == 385)
  519.                                        {
  520.                                           set("\x01",eval("\x01") - 260);
  521.                                           continue;
  522.                                        }
  523.                                        if(eval("\x01") == 230)
  524.                                        {
  525.                                           set("\x01",eval("\x01") - 170);
  526.                                           ┬º┬ºpush("\x0f");
  527.                                           continue;
  528.                                        }
  529.                                        if(eval("\x01") != 681)
  530.                                        {
  531.                                           if(eval("\x01") == 60)
  532.                                           {
  533.                                              set("\x01",eval("\x01") + 357);
  534.                                              ┬º┬ºpush(eval(┬º┬ºpop()));
  535.                                           }
  536.                                           else if(eval("\x01") == 303)
  537.                                           {
  538.                                              set("\x01",eval("\x01") + 688);
  539.                                           }
  540.                                           else
  541.                                           {
  542.                                              if(eval("\x01") == 205)
  543.                                              {
  544.                                                 break;
  545.                                              }
  546.                                              if(eval("\x01") == 991)
  547.                                              {
  548.                                                 set("\x01",eval("\x01") - 289);
  549.                                                 ┬º┬ºpush(true);
  550.                                              }
  551.                                              else if(eval("\x01") == 404)
  552.                                              {
  553.                                                 set("\x01",eval("\x01") + 73);
  554.                                                 if(┬º┬ºpop())
  555.                                                 {
  556.                                                    set("\x01",eval("\x01") + 0);
  557.                                                 }
  558.                                              }
  559.                                              else
  560.                                              {
  561.                                                 if(eval("\x01") == 367)
  562.                                                 {
  563.                                                    set("\x01",eval("\x01") - 367);
  564.                                                    break loop0;
  565.                                                 }
  566.                                                 if(eval("\x01") != 702)
  567.                                                 {
  568.                                                    break loop0;
  569.                                                 }
  570.                                                 set("\x01",eval("\x01") - 21);
  571.                                                 if(┬º┬ºpop())
  572.                                                 {
  573.                                                    set("\x01",eval("\x01") - 296);
  574.                                                 }
  575.                                              }
  576.                                           }
  577.                                           continue;
  578.                                        }
  579.                                        set("\x01",eval("\x01") - 296);
  580.                                        loop9:
  581.                                        while(true)
  582.                                        {
  583.                                           if(┬º┬ºpop() == ┬º┬ºpop())
  584.                                           {
  585.                                              set("\x01",eval("\x01") - 506);
  586.                                           }
  587.                                           else if(eval("\x01") == 40)
  588.                                           {
  589.                                              set("\x01",eval("\x01") + 226);
  590.                                              if(┬º┬ºpop())
  591.                                              {
  592.                                                 set("\x01",eval("\x01") - 67);
  593.                                              }
  594.                                           }
  595.                                           else if(eval("\x01") == 696)
  596.                                           {
  597.                                              set("\x01",eval("\x01") - 210);
  598.                                           }
  599.                                           else if(eval("\x01") == 199)
  600.                                           {
  601.                                              set("\x01",eval("\x01") + 378);
  602.                                           }
  603.                                           else if(eval("\x01") == 690)
  604.                                           {
  605.                                              set("\x01",eval("\x01") - 113);
  606.                                           }
  607.                                           else if(eval("\x01") == 900)
  608.                                           {
  609.                                              set("\x01",eval("\x01") + 52);
  610.                                              var ┬º┬ºpop() = ┬º┬ºpop();
  611.                                           }
  612.                                           else
  613.                                           {
  614.                                              if(eval("\x01") != 952)
  615.                                              {
  616.                                                 if(eval("\x01") == 104)
  617.                                                 {
  618.                                                    set("\x01",eval("\x01") - 104);
  619.                                                    break loop0;
  620.                                                 }
  621.                                                 break loop0;
  622.                                              }
  623.                                              set("\x01",eval("\x01") - 437);
  624.                                              ┬º┬ºpush("\x0f");
  625.                                           }
  626.                                           while(true)
  627.                                           {
  628.                                              if(eval("\x01") == 701)
  629.                                              {
  630.                                                 set("\x01",eval("\x01") - 341);
  631.                                                 ┬º┬ºpush(true);
  632.                                                 continue;
  633.                                              }
  634.                                              if(eval("\x01") == 577)
  635.                                              {
  636.                                                 set("\x01",eval("\x01") + 323);
  637.                                                 ┬º┬ºpush("\x0f");
  638.                                                 ┬º┬ºpush(1);
  639.                                                 continue;
  640.                                              }
  641.                                              if(eval("\x01") == 486)
  642.                                              {
  643.                                                 set("\x01",eval("\x01") - 446);
  644.                                                 ┬º┬ºpush(true);
  645.                                                 continue;
  646.                                              }
  647.                                              if(eval("\x01") == 773)
  648.                                              {
  649.                                                 set("\x01",eval("\x01") - 653);
  650.                                                 ┬º┬ºpush(!┬º┬ºpop());
  651.                                                 continue;
  652.                                              }
  653.                                              if(eval("\x01") == 211)
  654.                                              {
  655.                                                 set("\x01",eval("\x01") - 29);
  656.                                                 continue;
  657.                                              }
  658.                                              if(eval("\x01") == 261)
  659.                                              {
  660.                                                 set("\x01",eval("\x01") + 249);
  661.                                                 if(┬º┬ºpop())
  662.                                                 {
  663.                                                    set("\x01",eval("\x01") + 482);
  664.                                                 }
  665.                                                 continue;
  666.                                              }
  667.                                              if(eval("\x01") == 360)
  668.                                              {
  669.                                                 set("\x01",eval("\x01") + 442);
  670.                                                 if(┬º┬ºpop())
  671.                                                 {
  672.                                                    set("\x01",eval("\x01") - 261);
  673.                                                 }
  674.                                                 continue;
  675.                                              }
  676.                                              if(eval("\x01") == 182)
  677.                                              {
  678.                                                 set("\x01",eval("\x01") + 79);
  679.                                                 ┬º┬ºpush(true);
  680.                                                 continue;
  681.                                              }
  682.                                              if(eval("\x01") != 266)
  683.                                              {
  684.                                                 if(eval("\x01") == 802)
  685.                                                 {
  686.                                                    break;
  687.                                                 }
  688.                                                 if(eval("\x01") == 656)
  689.                                                 {
  690.                                                    set("\x01",eval("\x01") - 552);
  691.                                                    Say("PC","deep","Well, I do too mum... I wish he\'d get back soon.");
  692.                                                    break loop0;
  693.                                                 }
  694.                                                 if(eval("\x01") == 541)
  695.                                                 {
  696.                                                    set("\x01",eval("\x01") - 359);
  697.                                                    continue;
  698.                                                 }
  699.                                                 if(eval("\x01") == 515)
  700.                                                 {
  701.                                                    set("\x01",eval("\x01") + 258);
  702.                                                    ┬º┬ºpush(eval(┬º┬ºpop()));
  703.                                                    continue;
  704.                                                 }
  705.                                                 if(eval("\x01") == 120)
  706.                                                 {
  707.                                                    set("\x01",eval("\x01") + 536);
  708.                                                    if(┬º┬ºpop())
  709.                                                    {
  710.                                                       set("\x01",eval("\x01") + 0);
  711.                                                    }
  712.                                                    continue;
  713.                                                 }
  714.                                                 if(eval("\x01") == 510)
  715.                                                 {
  716.                                                    set("\x01",eval("\x01") + 482);
  717.                                                    break loop0;
  718.                                                 }
  719.                                                 continue loop9;
  720.                                              }
  721.                                              set("\x01",eval("\x01") - 67);
  722.                                              loop11:
  723.                                              while(true)
  724.                                              {
  725.                                                 if(!┬º┬ºpop())
  726.                                                 {
  727.                                                    set("\x01",eval("\x01") - 929);
  728.                                                    ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop();
  729.                                                    break loop0;
  730.                                                 }
  731.                                                 if(eval("\x01") == 128)
  732.                                                 {
  733.                                                    set("\x01",eval("\x01") + 733);
  734.                                                    ┬º┬ºpush("\x0f");
  735.                                                 }
  736.                                                 else if(eval("\x01") == 873)
  737.                                                 {
  738.                                                    set("\x01",eval("\x01") - 241);
  739.                                                    ┬º┬ºpush(true);
  740.                                                 }
  741.                                                 else
  742.                                                 {
  743.                                                    if(eval("\x01") == 185)
  744.                                                    {
  745.                                                       set("\x01",eval("\x01") - 185);
  746.                                                       break loop0;
  747.                                                    }
  748.                                                    if(eval("\x01") == 10)
  749.                                                    {
  750.                                                       set("\x01",eval("\x01") + 863);
  751.                                                    }
  752.                                                    else if(eval("\x01") == 168)
  753.                                                    {
  754.                                                       set("\x01",eval("\x01") + 705);
  755.                                                    }
  756.                                                    else if(eval("\x01") == 443)
  757.                                                    {
  758.                                                       set("\x01",eval("\x01") - 274);
  759.                                                    }
  760.                                                    else if(eval("\x01") == 344)
  761.                                                    {
  762.                                                       set("\x01",eval("\x01") - 175);
  763.                                                    }
  764.                                                    else
  765.                                                    {
  766.                                                       if(eval("\x01") != 463)
  767.                                                       {
  768.                                                          break loop0;
  769.                                                       }
  770.                                                       set("\x01",eval("\x01") - 335);
  771.                                                       var ┬º┬ºpop() = ┬º┬ºpop();
  772.                                                    }
  773.                                                 }
  774.                                                 while(true)
  775.                                                 {
  776.                                                    if(eval("\x01") == 915)
  777.                                                    {
  778.                                                       set("\x01",eval("\x01") - 67);
  779.                                                       ┬º┬ºpush(true);
  780.                                                       continue;
  781.                                                    }
  782.                                                    if(eval("\x01") == 219)
  783.                                                    {
  784.                                                       set("\x01",eval("\x01") + 125);
  785.                                                       prevFrame();
  786.                                                       break loop0;
  787.                                                    }
  788.                                                    if(eval("\x01") == 861)
  789.                                                    {
  790.                                                       set("\x01",eval("\x01") - 669);
  791.                                                       ┬º┬ºpush(eval(┬º┬ºpop()));
  792.                                                       continue;
  793.                                                    }
  794.                                                    if(eval("\x01") == 848)
  795.                                                    {
  796.                                                       set("\x01",eval("\x01") + 91);
  797.                                                       if(┬º┬ºpop())
  798.                                                       {
  799.                                                          set("\x01",eval("\x01") - 929);
  800.                                                       }
  801.                                                       continue;
  802.                                                    }
  803.                                                    if(eval("\x01") == 410)
  804.                                                    {
  805.                                                       set("\x01",eval("\x01") + 410);
  806.                                                       if(┬º┬ºpop())
  807.                                                       {
  808.                                                          set("\x01",eval("\x01") + 0);
  809.                                                       }
  810.                                                       continue;
  811.                                                    }
  812.                                                    if(eval("\x01") == 192)
  813.                                                    {
  814.                                                       set("\x01",eval("\x01") + 218);
  815.                                                       ┬º┬ºpush(!┬º┬ºpop());
  816.                                                       continue;
  817.                                                    }
  818.                                                    if(eval("\x01") == 632)
  819.                                                    {
  820.                                                       set("\x01",eval("\x01") - 413);
  821.                                                       if(┬º┬ºpop())
  822.                                                       {
  823.                                                          set("\x01",eval("\x01") + 125);
  824.                                                       }
  825.                                                       continue;
  826.                                                    }
  827.                                                    if(eval("\x01") == 169)
  828.                                                    {
  829.                                                       set("\x01",eval("\x01") + 294);
  830.                                                       ┬º┬ºpush("\x0f");
  831.                                                       ┬º┬ºpush(1);
  832.                                                       continue;
  833.                                                    }
  834.                                                    if(eval("\x01") == 820)
  835.                                                    {
  836.                                                       set("\x01",eval("\x01") - 635);
  837.                                                       gotoAndStop("B");
  838.                                                       break loop0;
  839.                                                    }
  840.                                                    continue loop11;
  841.                                                 }
  842.                                              }
  843.                                           }
  844.                                           set("\x01",eval("\x01") - 261);
  845.                                           tellTarget(delete ┬º┬ºpop())
  846.                                           {
  847.                                              tellTarget(┬º┬ºpop() == ┬º┬ºpop())
  848.                                              {
  849.                                                 tellTarget(┬º┬ºpop() | ┬º┬ºpop() << ┬º┬ºpop())
  850.                                                 {
  851.                                                    throw ┬º┬ºpop();
  852.                                                 }
  853.                                              }
  854.                                           }
  855.                                        }
  856.                                     }
  857.                                  }
  858.                                  set("\x01",eval("\x01") - 562);
  859.                                  break loop0;
  860.                               }
  861.                               if(eval("\x01") == 221)
  862.                               {
  863.                                  break loop5;
  864.                               }
  865.                               if(eval("\x01") != 50)
  866.                               {
  867.                                  if(eval("\x01") == 443)
  868.                                  {
  869.                                     set("\x01",eval("\x01") + 81);
  870.                                     break loop0;
  871.                                  }
  872.                                  if(eval("\x01") == 968)
  873.                                  {
  874.                                     set("\x01",eval("\x01") - 525);
  875.                                     if(┬º┬ºpop())
  876.                                     {
  877.                                        set("\x01",eval("\x01") + 81);
  878.                                     }
  879.                                     continue;
  880.                                     ┬º┬ºpush(!┬º┬ºpop());
  881.                                  }
  882.                                  if(eval("\x01") == 366)
  883.                                  {
  884.                                     set("\x01",eval("\x01") - 145);
  885.                                     if(┬º┬ºpop())
  886.                                     {
  887.                                        set("\x01",eval("\x01") + 546);
  888.                                     }
  889.                                     continue;
  890.                                  }
  891.                                  if(eval("\x01") == 572)
  892.                                  {
  893.                                     set("\x01",eval("\x01") - 304);
  894.                                     ┬º┬ºpush("\x0f");
  895.                                     ┬º┬ºpush(1);
  896.                                     continue;
  897.                                  }
  898.                                  if(eval("\x01") == 268)
  899.                                  {
  900.                                     set("\x01",eval("\x01") + 616);
  901.                                     var ┬º┬ºpop() = ┬º┬ºpop();
  902.                                     continue;
  903.                                  }
  904.                                  if(eval("\x01") == 516)
  905.                                  {
  906.                                     set("\x01",eval("\x01") - 150);
  907.                                     ┬º┬ºpush(true);
  908.                                     continue;
  909.                                  }
  910.                                  if(eval("\x01") != 884)
  911.                                  {
  912.                                     if(eval("\x01") != 334)
  913.                                     {
  914.                                        if(eval("\x01") == 524)
  915.                                        {
  916.                                           break;
  917.                                        }
  918.                                        if(eval("\x01") == 681)
  919.                                        {
  920.                                           set("\x01",eval("\x01") - 109);
  921.                                           continue;
  922.                                           continue;
  923.                                        }
  924.                                        if(eval("\x01") == 208)
  925.                                        {
  926.                                           set("\x01",eval("\x01") + 787);
  927.                                           if(┬º┬ºpop())
  928.                                           {
  929.                                              set("\x01",eval("\x01") - 832);
  930.                                           }
  931.                                           continue;
  932.                                        }
  933.                                        if(eval("\x01") == 17)
  934.                                        {
  935.                                           set("\x01",eval("\x01") + 191);
  936.                                           ┬º┬ºpush(true);
  937.                                           continue;
  938.                                        }
  939.                                        if(eval("\x01") == 163)
  940.                                        {
  941.                                           set("\x01",eval("\x01") + 409);
  942.                                           continue;
  943.                                        }
  944.                                        if(eval("\x01") == 767)
  945.                                        {
  946.                                           set("\x01",eval("\x01") - 750);
  947.                                           continue;
  948.                                        }
  949.                                        if(eval("\x01") == 604)
  950.                                        {
  951.                                           set("\x01",eval("\x01") - 119);
  952.                                           ┬º┬ºpush(eval(┬º┬ºpop()));
  953.                                           continue;
  954.                                        }
  955.                                     }
  956.                                     set("\x01",eval("\x01") - 317);
  957.                                     continue;
  958.                                     if(eval("\x01") != 485)
  959.                                     {
  960.                                        if(eval("\x01") != 878)
  961.                                        {
  962.                                           if(eval("\x01") == 911)
  963.                                           {
  964.                                              set("\x01",eval("\x01") - 524);
  965.                                              Say("Deugan","smile","It sure is.");
  966.                                              break loop0;
  967.                                           }
  968.                                           if(eval("\x01") == 387)
  969.                                           {
  970.                                              set("\x01",eval("\x01") - 387);
  971.                                              break loop0;
  972.                                           }
  973.                                        }
  974.                                        set("\x01",eval("\x01") + 33);
  975.                                        if(┬º┬ºpop())
  976.                                        {
  977.                                           set("\x01",eval("\x01") + 0);
  978.                                        }
  979.                                     }
  980.                                     set("\x01",eval("\x01") + 393);
  981.                                  }
  982.                               }
  983.                               set("\x01",eval("\x01") + 466);
  984.                               continue;
  985.                               set("\x01",eval("\x01") - 280);
  986.                            }
  987.                            set("\x01",eval("\x01") + 438);
  988.                            ┬º┬ºpush(true);
  989.                            continue;
  990.                            ┬º┬ºpush("\x0f");
  991.                         }
  992.                      }
  993.                      set("\x01",eval("\x01") + 546);
  994.                      loop13:
  995.                      while(true)
  996.                      {
  997.                         set(┬º┬ºpop(),┬º┬ºpop() - 204);
  998.                         while(true)
  999.                         {
  1000.                            if(eval("\x01") == 106)
  1001.                            {
  1002.                               set("\x01",eval("\x01") + 820);
  1003.                               ┬º┬ºpush(true);
  1004.                            }
  1005.                            else if(eval("\x01") == 589)
  1006.                            {
  1007.                               set("\x01",eval("\x01") + 134);
  1008.                            }
  1009.                            else
  1010.                            {
  1011.                               if(eval("\x01") == 927)
  1012.                               {
  1013.                                  break;
  1014.                               }
  1015.                               if(eval("\x01") == 723)
  1016.                               {
  1017.                                  set("\x01",eval("\x01") - 293);
  1018.                                  ┬º┬ºpush("\x0f");
  1019.                                  ┬º┬ºpush(1);
  1020.                               }
  1021.                               else if(eval("\x01") == 926)
  1022.                               {
  1023.                                  set("\x01",eval("\x01") - 600);
  1024.                                  if(┬º┬ºpop())
  1025.                                  {
  1026.                                     set("\x01",eval("\x01") + 601);
  1027.                                  }
  1028.                               }
  1029.                               else
  1030.                               {
  1031.                                  if(eval("\x01") == 135)
  1032.                                  {
  1033.                                     break loop13;
  1034.                                  }
  1035.                                  if(eval("\x01") == 326)
  1036.                                  {
  1037.                                     set("\x01",eval("\x01") + 601);
  1038.                                     break loop0;
  1039.                                  }
  1040.                                  if(eval("\x01") == 937)
  1041.                                  {
  1042.                                     set("\x01",eval("\x01") - 277);
  1043.                                     ┬º┬ºpush("\x0f");
  1044.                                  }
  1045.                                  else if(eval("\x01") == 430)
  1046.                                  {
  1047.                                     set("\x01",eval("\x01") + 507);
  1048.                                     var ┬º┬ºpop() = ┬º┬ºpop();
  1049.                                  }
  1050.                                  else if(eval("\x01") == 660)
  1051.                                  {
  1052.                                     set("\x01",eval("\x01") + 331);
  1053.                                     ┬º┬ºpush(eval(┬º┬ºpop()));
  1054.                                  }
  1055.                                  else if(eval("\x01") == 991)
  1056.                                  {
  1057.                                     set("\x01",eval("\x01") - 541);
  1058.                                     ┬º┬ºpush(!┬º┬ºpop());
  1059.                                  }
  1060.                                  else
  1061.                                  {
  1062.                                     if(eval("\x01") != 450)
  1063.                                     {
  1064.                                        if(eval("\x01") == 509)
  1065.                                        {
  1066.                                           set("\x01",eval("\x01") - 509);
  1067.                                           break loop0;
  1068.                                        }
  1069.                                        break loop0;
  1070.                                     }
  1071.                                     set("\x01",eval("\x01") - 315);
  1072.                                     if(┬º┬ºpop())
  1073.                                     {
  1074.                                        set("\x01",eval("\x01") + 0);
  1075.                                     }
  1076.                                  }
  1077.                               }
  1078.                            }
  1079.                         }
  1080.                      }
  1081.                      set("\x01",eval("\x01") + 374);
  1082.                      Say("","norm","Oh well. Time does fly when you\'re having fun.");
  1083.                      break loop0;
  1084.                   }
  1085.                   if(eval("\x01") != 763)
  1086.                   {
  1087.                      break;
  1088.                   }
  1089.                   set("\x01",eval("\x01") - 483);
  1090.                   if(┬º┬ºpop())
  1091.                   {
  1092.                      set("\x01",eval("\x01") - 80);
  1093.                   }
  1094.                }
  1095.             }
  1096.          }
  1097.       }
  1098.    }
  1099. }
  1100.